Workflow Automator

The Workflow Automator skill identifies repetitive tasks and designs automated workflows using GitHub Actions, webhooks, MCP servers, and integration tools. It focuses on eliminating manual work, reducing errors, and accelerating delivery through intelligent automation.

This skill excels at analyzing existing processes, identifying automation opportunities, designing workflow diagrams, implementing automation scripts, and monitoring automated systems for reliability and efficiency gains.

Workflow Automator emphasizes pragmatic automation: automate what saves time, maintain what's automated, and keep humans in the loop for critical decisions.

Core Workflows

Workflow 1: Identify Automation Opportunities

Steps:

Process Audit

Map current workflows and process steps

Identify repetitive manual tasks

Measure time spent on each task

Document pain points and error sources

List all tools and systems involved

Automation Assessment

For each task, evaluate:

Frequency

How often is it done?

Volume

How many times per day/week?

Consistency

Same steps every time?

Rule-based

Can it be defined by logic?

ROI

Time saved vs. automation effort

Prioritize Automation

High priority: Frequent, high-volume, error-prone

Medium priority: Moderate frequency, clear rules

Low priority: Rare, complex, requires judgment

Calculate ROI: (Time saved per month) / (Build time)

Create Automation Roadmap

List automations by priority

Estimate build effort (hours)

Identify dependencies and prerequisites

Assign owners and timeline

Output:

Prioritized automation backlog with ROI estimates.

Workflow 2: Design Automated Workflow

Steps:

Define Trigger

What event starts the workflow?

Examples: Git push, PR created, schedule, webhook, file upload

Specify trigger conditions and filters

Map Workflow Steps

List each action in sequence

Identify decision points (if/then logic)

Define parallel vs. sequential steps

Specify timeout and retry behavior

Define Data Flow

What data inputs are needed?

How is data transformed between steps?

Where is data stored or logged?

What outputs are produced?

Error Handling

What can go wrong at each step?

How should errors be handled? (retry, alert, skip, fail)

Who gets notified on failure?

What rollback procedures are needed?

Create Workflow Diagram

Visual representation of flow

Show triggers, steps, decisions, outputs

Document expected duration

Note dependencies and integrations

Output:

Workflow specification document with diagram.

Workflow 3: Implement Automation

Steps:

Choose Automation Tool

GitHub Actions: CI/CD, git-triggered workflows

Webhooks: Event-driven integrations

Cron Jobs: Scheduled tasks

MCP Servers: AI-powered automations

Zapier/Make: No-code integrations

Custom Scripts: Specialized needs

Write Automation Code

Follow workflow specification

Implement error handling and logging

Add configuration for flexibility

Include documentation and comments

Write tests for automation logic

Test Automation

Test happy path (everything works)

Test error cases (failures, timeouts)

Test edge cases (empty data, duplicates)

Verify notifications and logging

Validate end-to-end flow

Deploy to Staging

Run in test environment first

Monitor for issues

Gather feedback from users

Adjust based on real-world behavior

Production Rollout

Deploy to production

Monitor closely for first 48 hours

Set up alerts for failures

Document runbooks for troubleshooting

Train team on automation

Output:

Production-ready automation with monitoring and documentation.

Workflow 4: Monitor and Optimize

Steps:

Track Metrics

Execution count and success rate

Average duration and performance

Error rate and types

Time saved vs. manual process

Cost (compute, API calls, etc.)

Regular Reviews

Weekly: Check for failures and alerts

Monthly: Review performance and efficiency

Quarterly: Assess ROI and value

Yearly: Evaluate if still needed

Continuous Improvement

Identify optimization opportunities

Reduce execution time

Improve error handling

Expand automation coverage

Refactor for maintainability

Quick Reference

Action

Command/Trigger

Analyze process

"find automation opportunities in [process]"

Design workflow

"design automation for [task]"

Create GitHub Action

"automate [task] with GitHub Actions"

Set up webhook

"create webhook for [event]"

Schedule task

"schedule [task] to run [frequency]"

Monitor automation

"check automation health"

Optimize workflow

"optimize [automation]"

Document workflow

"document [automation] workflow"

Best Practices

Start small

Automate simple, high-ROI tasks first; build momentum with quick wins

Make it reliable

95%+ success rate minimum; unreliable automation is worse than manual work

Design for failure

Assume everything can fail; handle errors gracefully and alert humans

Log everything

Comprehensive logging enables debugging and auditing

Keep it simple

Complex automations are hard to maintain; favor simple, modular workflows

Version control

Store automation code in git; track changes and enable rollback

Test thoroughly

Test happy path, error cases, and edge cases before production

Monitor actively

Set up alerts and dashboards; know when automation breaks

Document clearly

Future you (or teammates) need to understand what it does and how to fix it

Maintain regularly

Review and update automations quarterly; remove obsolete ones

Human oversight

Keep humans in loop for critical decisions; automation assists, doesn't replace judgment

Measure impact

Track time saved and ROI; justify automation investment with data

Common Automation Patterns

1. CI/CD Pipeline

Trigger

Git push or PR

Steps

:

Run linter and formatter

Run unit and integration tests

Build application

Run E2E tests

Deploy to staging

Run smoke tests

Deploy to production (on merge)

Notify team on completion or failure

2. Issue Triage

Trigger

New GitHub issue created

Steps

:

Analyze issue content

Label by type (bug, feature, question)

Assign to appropriate team

Add to project board

Notify team in Slack

Auto-reply with acknowledgment

3. Dependency Updates

Trigger

Weekly schedule

Steps

:

Check for package updates

Create PR with updates

Run full test suite

Request review from team

Auto-merge if tests pass and minor version

4. Performance Monitoring

Trigger

Every hour

Steps

:

Check API response times

Measure database query performance

Analyze error rates

Check resource usage (CPU, memory)

Alert if thresholds exceeded

Log metrics to dashboard

5. Customer Onboarding

Trigger

New user signup

Steps

:

Send welcome email

Create user account and resources

Schedule onboarding emails (drip campaign)

Add to CRM

Notify sales team if enterprise plan

Track onboarding completion

6. Backup and Archival

Trigger

Daily at 2 AM

Steps

:

Backup database

Backup uploaded files

Compress and encrypt backups

Upload to S3 or backup service

Verify backup integrity

Delete backups older than 30 days

Alert if backup fails

7. Code Review Reminder

Trigger

PR open for 24 hours without review

Steps

:

Identify pending PRs

Check assigned reviewers

Send reminder to reviewers

Escalate if urgent

Track review SLA metrics

8. Release Notes Generation

Trigger

Tag pushed (version release)

Steps

:

Gather commits since last release

Categorize changes (features, fixes, breaking)

Generate release notes from PR descriptions

Create GitHub release

Post to changelog page

Notify team and customers

Automation ROI Calculator

Time Saved Per Month = (Task Duration × Frequency per Month)

Build Time = Hours to implement + Hours to test + Hours to document

Payback Period = Build Time / Time Saved Per Month

Example:

- Task: Deploy to staging (30 min manual)

- Frequency: 40 times/month

- Time Saved: 30 min × 40 = 20 hours/month

- Build Time: 8 hours

- Payback: 8 / 20 = 0.4 months (12 days)

- ROI after 1 year: (20 × 12) - 8 = 232 hours saved

Rule of Thumb

If payback period < 3 months, automate it.

Automation Technology Guide

Use Case

Tool

Complexity

Best For

Git-triggered workflows

GitHub Actions

Medium

CI/CD, testing, deployment

Event integrations

Webhooks

Medium

Real-time notifications

Scheduled tasks

Cron Jobs

Low

Backups, reports, cleanup

No-code automation

Zapier/Make

Low

Simple integrations

API automation

Node/Python scripts

Medium

Custom logic, complex flows

AI-powered workflows

MCP Servers

High

Smart routing, content analysis

Database automation

Triggers/Procedures

Medium

Data validation, calculations

Browser automation

Playwright MCP

Medium

Web scraping, testing, monitoring

Error Handling Patterns

Retry Logic

-

Transient errors

:

Retry 3 times with exponential backoff

-

Rate limits

:

Wait and retry after delay

-

Permanent errors

:

Fail fast and alert

Fallback Strategies

-

Primary action fails

:

Try secondary action

-

API unavailable

:

Use cached data

-

Service down

:

Queue for later processing

Alerting Hierarchy

-

Info

:

Log only

-

Warning

:

Log and notify on

-

call during business hours

-

Error

:

Immediate alert to on

-

call

-

Critical

:

Page on

-

call and escalate to team lead

Integration Points

GitHub Actions

Primary CI/CD automation platform

Webhooks

Event-driven integrations with external services

MCP Servers

AI-powered workflow automation

Playwright MCP

Browser automation for testing and scraping

Supabase

Database triggers and Edge Functions

Slack/Discord

Notifications and bot commands

Monitoring Tools

Sentry, DataDog, New Relic for observability